import {LogCategory, logger} from '../../logger';
import {BaseStoreService} from './BaseStoreService';
import {SessionSchema} from '../types';

/**
 * 会话存储服务类
 * 负责管理浏览会话数据
 */
export class SessionService extends BaseStoreService<SessionSchema> {
  private static instance: SessionService;

  /**
   * 私有构造函数
   */
  private constructor() {
    super('Session', {
      lastClosedTabs: [],
      currentTabs: []
    });
  }

  /**
   * 获取SessionService单例实例
   */
  public static getInstance(): SessionService {
    if (!SessionService.instance) {
      SessionService.instance = new SessionService();
    }
    return SessionService.instance;
  }

  /**
   * 获取当前会话标签页
   */
  public getCurrentTabs(): SessionSchema['currentTabs'] {
    logger.debug(this.moduleName, LogCategory.SYSTEM, '获取当前会话标签页');
    return this.store.get('currentTabs');
  }

  /**
   * 更新当前会话标签页
   * @param tabs 标签页数据
   */
  public updateCurrentTabs(tabs: SessionSchema['currentTabs']): void {
    logger.debug(this.moduleName, LogCategory.SYSTEM, `更新当前会话标签页，数量: ${tabs.length}`);
    this.store.set('currentTabs', tabs);
  }

  /**
   * 获取最近关闭的标签页
   */
  public getLastClosedTabs(): SessionSchema['lastClosedTabs'] {
    logger.debug(this.moduleName, LogCategory.SYSTEM, '获取最近关闭的标签页');
    return this.store.get('lastClosedTabs');
  }

  /**
   * 添加到最近关闭的标签页
   * @param tab 标签页数据
   */
  public addToLastClosedTabs(tab: Omit<SessionSchema['lastClosedTabs'][0], 'createdAt'>): void {
    logger.debug(this.moduleName, LogCategory.SYSTEM, `添加到最近关闭的标签页: ${tab.title}, URL: ${tab.url}`);

    const lastClosedTabs = this.getLastClosedTabs();
    const newTab = {
      ...tab,
      createdAt: Date.now()
    };

    // 保持最近关闭的标签页数量限制为20个
    const updatedTabs = [newTab, ...lastClosedTabs].slice(0, 20);
    this.store.set('lastClosedTabs', updatedTabs);
  }

  /**
   * 恢复最近关闭的标签页
   * @param index 索引位置，默认为0（最近关闭的标签）
   */
  public restoreClosedTab(index: number = 0): SessionSchema['lastClosedTabs'][0] | null {
    try {
      const lastClosedTabs = this.getLastClosedTabs();

      if (lastClosedTabs.length === 0 || index >= lastClosedTabs.length) {
        logger.warn(this.moduleName, LogCategory.SYSTEM, '没有可恢复的标签页');
        return null;
      }

      // 获取要恢复的标签页
      const tabToRestore = lastClosedTabs[index];
      logger.info(this.moduleName, LogCategory.SYSTEM, `恢复标签页: ${tabToRestore.title}, URL: ${tabToRestore.url}`);

      // 从关闭列表中移除
      const updatedTabs = lastClosedTabs.filter((_, i) => i !== index);
      this.store.set('lastClosedTabs', updatedTabs);

      return tabToRestore;
    } catch (error) {
      logger.error(this.moduleName, LogCategory.SYSTEM, '恢复标签页失败', error);
      return null;
    }
  }

  /**
   * 清理存储数据
   */
  public cleanupStore(): void {
    try {
      logger.info(this.moduleName, LogCategory.SYSTEM, '会话数据存储清理');

      // 获取当前设置，判断是否需要保留会话
      const shouldRestoreTabs = true; // 这里应该从设置中读取

      if (!shouldRestoreTabs) {
        // 如果不需要恢复会话，清空当前标签记录
        this.store.set('currentTabs', []);
        logger.info(this.moduleName, LogCategory.SYSTEM, '已清理当前会话标签数据');
      }

      // 可以选择性地保留部分最近关闭的标签
      const lastClosedTabs = this.getLastClosedTabs();
      if (lastClosedTabs.length > 10) {
        // 只保留最近的10个
        this.store.set('lastClosedTabs', lastClosedTabs.slice(0, 10));
        logger.info(this.moduleName, LogCategory.SYSTEM, `保留最近10个关闭的标签页，清理${lastClosedTabs.length - 10}项`);
      }
    } catch (error) {
      logger.error(this.moduleName, LogCategory.SYSTEM, '会话数据存储清理失败', error);
    }
  }
}
